package com.my.commonlib.util;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Color;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.text.Editable;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.TextUtils;
import android.text.style.ForegroundColorSpan;
import android.text.style.StyleSpan;
import android.util.Log;

import com.my.commonlib.BaseApplication;

import java.io.File;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class StrUtil {
    /**
     * 字符串转为大写
     *
     * @param str
     * @return String
     */
    public static String toUpper(String str) {
        if (TextUtils.isEmpty(str)) {
            return "";
        }

        return str.toUpperCase(Locale.US);
    }


    /**
     * 字符串转为小写
     *
     * @param str
     * @return String
     */
    public static String toLower(String str) {
        if (TextUtils.isEmpty(str)) {
            return "";
        }

        return str.toLowerCase(Locale.US);
    }

    /**
     * 字符串转为整数，并忽略错误
     *
     * @param str 需要转为整数的字符串
     * @return int 转换后的整数；如出错则返回0
     */
    public static int toInt(String str) {
        if (TextUtils.isEmpty(str)) {
            return 0;
        }

        int retValue;

        try {
            retValue = Integer.parseInt(str);
        } catch (Exception e) {
            e.printStackTrace();
            retValue = 0;
        }

        return retValue;
    }

    /**
     * 字符串转为long型整数，并忽略错误
     *
     * @param str 需要转为整数的字符串
     * @return long 转换后的整数；如出错则返回0
     */
    public static long toLong(String str) {
        if (TextUtils.isEmpty(str)) {
            return 0;
        }

        long retValue;

        try {
            retValue = Long.parseLong(str);
        } catch (Exception e) {
            e.printStackTrace();
            retValue = 0;
        }

        return retValue;
    }

    /**
     * 字符串转为 double 类型数字，并忽略错误
     *
     * @param str 需要转为double 类型数字的字符串
     * @return double 转换后的整数；如出错则返回0
     */
    public static double toDouble(String str) {
        if (TextUtils.isEmpty(str)) {
            return 0;
        }

        double retValue = 0;

        try {
            retValue = Double.parseDouble(str);
        } catch (Exception e) {
            e.printStackTrace();
            retValue = 0;
        }

        return retValue;
    }

    /**
     * 字符串转为 float 类型数字，并忽略错误
     *
     * @param str 需要转为double 类型数字的字符串
     * @return double 转换后的整数；如出错则返回0
     */
    public static float toFloat(String str) {
        if (TextUtils.isEmpty(str)) {
            return 0F;
        }

        float retValue = 0;

        try {
            retValue = Float.parseFloat(str);
        } catch (Exception e) {
            e.printStackTrace();
            retValue = 0;
        }

        return retValue;
    }

    /**
     * @param str
     * @return
     */
    public static int[] toChar(String str) {
        if (!TextUtils.isEmpty(str)) {
            char[] strs = str.toCharArray();
            int[] ints = new int[strs.length];
            for (int i = 0; i < strs.length; i++) {
                ints[i] = (int) strs[i];
            }
            return ints;
        }
        return new int[]{};
    }


    /**
     * 用正则表达式替换
     *
     * @param source_string
     * @param pattern_string
     * @param replace_string
     * @return String
     */
    public static String replacePattern(String source_string, String pattern_string, String replace_string) {
        StringBuffer sb = new StringBuffer();

        try {
            Matcher matcher = Pattern.compile(pattern_string).matcher(source_string);

            while (matcher.find()) {
                matcher.appendReplacement(sb, replace_string);
            }

            matcher.appendTail(sb);
        } catch (Exception e) {
            return "";
        }

        return sb.toString();
    }

    public static String getString(String data, int d) {
        int[] ints = toChar(data);
        ints = yihuo(cheng(ints, d));
        String str = "";
        for (int i = 0; i < ints.length; i++) {
            str += ints[i];
        }
        return Md5.StringToMD5(str);
    }

    public static int[] yihuo(int[] ss) {
        for (int i = 0; i < ss.length; i++) {
            int t = ss[i];
            t = t ^ (i % 3);
            t = t >> 3;
            if (i % 3 == 0) {
                t = t << 2;
            } else {
                t = t ^ ss[i];
            }
            ss[i] = t;
        }
        return ss;
    }

    public static int[] cheng(int[] chr, int day) {
        int[] ss = new int[chr.length];
        for (int i = 0; i < chr.length; i++) {
            if (i % 2 != 0) {
                ss[i] = chr[i] - i * 2 + day;
            } else {
                ss[i] = chr[i];
            }
        }
        return ss;
    }

    /**
     * 当前时间日期对象格式化为字符串
     *
     * @return String
     */
    public static String fromDate() {
        return fromDate(null, null);
    }

    /**
     * 时间日期对象格式化为字符串
     *
     * @param inputDate
     * @return String
     */
    public static String fromDate(Date inputDate) {
        return fromDate(inputDate, null);
    }

    /**
     * 时间日期对象格式化为字符串
     *
     * @param inputDate
     * @param strFormatter
     * @return String
     */
    public static String fromDate(Date inputDate, String strFormatter) {
        if (null == inputDate) {
            inputDate = new Date();
        }

        if (null == strFormatter) {
            strFormatter = "";
        }

        strFormatter = strFormatter.trim();

        if (strFormatter.length() < 1) {
            strFormatter = "yyyy-MM-dd HH:mm:ss";
        }

        SimpleDateFormat sf = new SimpleDateFormat(strFormatter, Locale.US);
        String retStr = sf.format(inputDate);

        return retStr;
    }


    public static boolean isLetter(char c) {
        int k = 0x80;
        return c / k == 0 ? true : false;
    }

    /**
     * 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为2,英文字符长度为1
     *
     * @param s s 需要得到长度的字符串
     * @return int 得到的字符串长度
     */
    public static int length(String s) {
        if (s == null)
            return 0;
        char[] c = s.toCharArray();
        int len = 0;
        for (int i = 0; i < c.length; i++) {
            len++;
            if (!isLetter(c[i])) {
                len++;
            }
        }
        return len;
    }

    /**
     * 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为1,英文字符长度为0.5
     *
     * @param s s 需要得到长度的字符串
     * @return int 得到的字符串长度
     */
    public static double getStringLength(String s) {
        double valueLength = 0;
        String chinese = "[\u4e00-\u9fa5]";
        // 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1
        for (int i = 0; i < s.length(); i++) {
            // 获取一个字符
            String temp = s.substring(i, i + 1);
            // 判断是否为中文字符
            if (temp.matches(chinese)) {
                // 中文字符长度为1
                valueLength += 1;
            } else {
                // 其他字符长度为0.5
                valueLength += 0.5;
            }
        }
        // 进位取整
//		return Math.ceil(valueLength);
        return valueLength;
    }


    /**
     * 过滤特殊字符
     *
     * @param str
     * @return true 包含特殊字符，false 没有特殊字符
     */
    public static boolean StringFilter(String str) {
        // 只允许字母和数字
        // String regEx = "[^a-zA-Z0-9]";
        // 清除掉所有特殊字符
        String regEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&amp;*（）——+|{}【】‘；：”“’。，、？]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.find();
//	  直接替换掉，
//	  return m.replaceAll("").trim();
    }


    public String stringFilter(String str) throws PatternSyntaxException {
        // 只允许字母和数字和中文//[\\pP‘’“”  
        String regEx = "^[A-Za-z\\d\\u4E00-\\u9FA5\\p{P}‘’“”]+$";
        Pattern p = Pattern.compile(regEx);
        StringBuilder sb = new StringBuilder(str);
//        int len = str.length();
        for (int len = str.length(), i = len - 1; i <= 0; --i) {

            if (!p.matches(regEx, String.valueOf(str.charAt(i)))) {
                Log.i("info", "======ssssss=表情=");
                sb.deleteCharAt(i);
            }
        }

        return sb.toString();
    }

    public static boolean isNotEmpty(String str) {
        if (str == null || str.trim().equals("")) {
            return false;
        } else {
            return true;
        }
    }

    //判断EditText 是否为空
    public static String isNotEmptyText(Editable able) {
        if (able != null && isNotEmpty(able.toString())) {
            return able.toString();
        } else {
            return null;
        }
    }

    private final static Pattern emailer = Pattern
            .compile("^([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)*@([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)+[\\.][A-Za-z]{2,3}([\\.][A-Za-z]{2})?$");

    private final static Pattern phones = Pattern
            .compile("^((13[0-9])|(14[0-9])|(17[0-9])|(15[^4,\\D])|(18[0-9]))\\d{8}$");

    private final static Pattern idcards = Pattern
            .compile("^(\\d{14}|\\d{17})(\\d|[xX])$");

    private final static Pattern realName = Pattern
            .compile("^[\u4E00-\u9FA5]{1,13}$");

    private final static Pattern noWord = Pattern
            .compile("^[^\u4e00-\u9fa5]{0,}$");
    //^[^\u4e00-\u9fa5]{0,}$

    //判断是否是电子邮件
    public static boolean isEmail(String email) {
        if (email == null || email.trim().length() == 0)
            return false;
        return emailer.matcher(email).matches();
    }

    //判断手机号码
    public static boolean isPhone(String phone) {
        if (phone == null || phone.trim().length() == 0)
            return false;
        return phones.matcher(phone).matches();
    }

    //判断不能输入汉字
    public static boolean isWord(String word) {
        if (word == null || word.trim().length() == 0)
            return false;
        return noWord.matcher(word).matches();
    }

    //判断手机号码
    public static boolean isIDCard(String idcard) {
        if (idcard == null || idcard.trim().length() == 0)
            return false;
        return idcards.matcher(idcard).matches();
    }

    //判断真实姓名
    public static boolean isRealName(String userName) {
        if (userName == null || userName.trim().length() == 0)
            return false;
        return realName.matcher(userName).matches();
    }

    //修改头像
    public void changeHeadImg(final Activity activity, String[] items, String title) {
        new AlertDialog.Builder(activity).setTitle(title).setItems(items, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which) {
                    case 0: // 相册
                        Intent intent = new Intent(Intent.ACTION_GET_CONTENT, null);
                        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
                        activity.startActivityForResult(intent, 1);
                        break;

                    case 1: // 相机
                        Intent intent1 = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        // 下面这句指定调用相机拍照后的照片存储的路径
                        intent1.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(Environment.getExternalStorageDirectory(), "headimg.jpg")));
                        activity.startActivityForResult(intent1, 2);
                        break;
                }
            }
        }).show();
    }

    /**
     * 裁剪图片方法实现
     * 6222 0010 0110 3861762
     *
     * @param uri
     */
    public void startPhotoZoom(Activity activity, Uri uri, int x, int y) {
        Logger.i("info","=====startPhotoZoom===="+uri.getPath());
        Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(uri, "image/*");
//        intent.setDataAndType(uri, IMAGE_UNSPECIFIED);//主要问题就在这个File Uri上面  ————代码语句A
//        intent.setDataAndType(getImageContentUri(context , inputfile), IMAGE_UNSPECIFIED);//自己
        // 下面这个crop=true是设置在开启的Intent中设置显示的VIEW可裁剪
        intent.putExtra("crop", "true");
        // aspectX aspectY 是宽高的比例
        intent.putExtra("aspectX", 1);
        intent.putExtra("aspectY", 1);
        // outputX outputY 是裁剪图片宽高
        intent.putExtra("outputX", x);
        intent.putExtra("outputY", y);
        intent.putExtra("return-data", true);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
        activity.startActivityForResult(intent, 3);
    }

    //获取资源
    public static String[] getResoucesArray(Context context, int id) {
        return context.getResources().getStringArray(id);
    }

    public static String getResoucesStr(Context context, int id) {
        return context.getResources().getString(id);
    }

    public static int getResoucesColor(Context context, int id) {
        return context.getResources().getColor(id);
    }

    public static float getResoucesDimen(Context context, int id) {
        return context.getResources().getDimension(id);
    }


    /**
     * String 类型 转double类型
     *
     * @param str
     * @param decimal
     * @return
     */

    public static String resultStr(String str, String decimal) {
        if (TextUtils.isEmpty(str)) {
            return "0.00";
        }
        try {
            double dstr = Double.parseDouble(str);
            DecimalFormat df = new DecimalFormat(decimal);
            str = df.format(dstr);
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "0.00";
        }
    }

    /**
     * 判断某个字符串是否存在于数组中
     *
     * @param stringArray 原数组
     * @param source      查找的字符串
     * @return 是否找到
     */
    public static boolean contains(String[] stringArray, String source) {
        // 转换为list
        List<String> tempList = Arrays.asList(stringArray);
        // 利用list的包含方法,进行判断
        if (tempList.contains(source)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 字符串转百分比
     *
     * @param value
     * @return
     */
    public static String formatPercent(String value) {
        NumberFormat num = NumberFormat.getPercentInstance();
        num.setMaximumIntegerDigits(3);
        num.setMaximumFractionDigits(0);
        Double cs = 0.0;
        if (StrUtil.isNotEmpty(value) && !value.equals("0")) {
            try {
                cs = Double.parseDouble(value);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            return "0%";
        }
        return num.format(cs);
    }

    /**
     * 转为int
     *
     * @param value
     * @return
     */
    public static int formatOne(String value, int c) {
        Double cs = 0.0;
        if (value != null) {
            try {
                cs = Double.parseDouble(value);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            return 0;
        }
        int index = (int) Math.ceil(cs * 100 / c);
        if (index == 0) {
            index = 1;
        }
        return index;
    }


    public static int getStrToColor(String str_color) {
        try {
            if (TextUtils.isEmpty(str_color)) {
                return 0;
            }
            str_color = str_color.trim();
            int color1;
            if (!str_color.startsWith("#")) {
                color1 = Color.parseColor("#" + str_color);
            } else {
                color1 = Color.parseColor(str_color);
            }
            return color1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取application中指定的meta-data
    * @return 如果没有获取成功(没有对应值，或者异常)，则返回值为空
    */
    public static String getAppMetaData(Context ctx, String key) {
        String resultData;
        resultData = "hhb";//AnalyticsConfig.getChannel(ctx);
        if(null==resultData){
            resultData = "";
        }
        return resultData;
    }


    /**
     * 设置字体不同颜色
     *
     * @param context
     * @param changeText  需要改变字体
     * @param changeColor 需要改变颜色
     * @param other       默认字
     * @param otherColor  默认颜色
     * @param length      变化颜色字体长度
     * @return
     */
    public static SpannableString setSpannableStringColor(Context context, String changeText, int changeColor, String other, int otherColor, int length) {
        SpannableString spannableString = new SpannableString(changeText + other);
        spannableString.setSpan(new ForegroundColorSpan(context.getResources().getColor(changeColor)), 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        spannableString.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        spannableString.setSpan(new ForegroundColorSpan(context.getResources().getColor(otherColor)), length, spannableString.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        return spannableString;
    }

    /**
     * 获取字符串资源
     *
     * @author agger
     * @date 2014-06-30
     * @param resourceID 字符串资源的ID
     * @return String 字符串
     */
    public static String getString(int resourceID) {
        try {
            return BaseApplication.getApp().getString(resourceID);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 判断邮箱
     * @param email
     * @return
     */
//    public static boolean isEmail(String email) {
//        String regex = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$"; //
//        return match(regex, email);
//    }
    /**
     * @param regex 正则表达式
     * @param str   要匹配的字符串
     * @return
     */
    private static boolean match(String regex, String str) {
        if (str == null || str.equals("")) {
            return false;
        }
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        return matcher.matches();
    }

    /**
     * 转百分比
     * @param diliverNum
     * @param queryMailNum
     * @return
     */
    public static int percent(int diliverNum,int queryMailNum){
        // 创建一个数值格式化对象
        NumberFormat numberFormat = NumberFormat.getInstance();
        // 设置精确到小数点后2位
        numberFormat.setMaximumFractionDigits(2);
        try {
            String result = numberFormat.format((float) diliverNum / (float) queryMailNum * 100);
            return ((int) Double.parseDouble(result));
        }catch (Exception e){
            e.printStackTrace();
        }
        return 0;
    }


}
